import java.util.ArrayList;
import java.util.HashMap;
import java.util.function.BiConsumer;

/**
 *  参数列表 -> 被用于
 */
public class TestDemo {

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "hello");
        map.put(2, "bit");
        map.put(3, "hello");
        map.put(4, "lambda");
//        map.forEach(new BiConsumer<Integer, String>(){
//            @Override
//            public void accept(Integer k, String v){
//                System.out.println(k + "=" + v);
//            }
//        });
        map.forEach((k,v) -> System.out.println(k + "=" + v));
    }

    public static void main5(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zh");
        list.add("bit");
        list.add("hello");
        list.add("world");
        list.add("lambda");

        // Collection 的 forEach方法
//        list.forEach(new Consumer<String>() {
//            @Override
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        list.forEach(s -> System.out.println(s));

        System.out.println("=============");

        // 2 List接口的 sort()方法
        list.sort((o1,o2) -> o1.compareTo(o2));
        list.forEach(s -> System.out.println(s));
    }

    public static void main4(String[] args) {
        /*
            匿名内部类里只能捕获 1.常量  2.未被修改过的变量
         */
        int size = 99;
//        size = 10;// 这里修改了，后面就捕获不到，报错
        OneParameterNoReturn oneParameterNoReturn = a -> {
            System.out.println(a);
            System.out.println(size);
        };
    }

    public static void main3(String[] args) {
        //无返回值一个参数 OneParameterNoReturn
        OneParameterNoReturn oneParameterNoReturn = a -> System.out.println(a);
        oneParameterNoReturn.test(3);

        //无返回值多个参数 MoreParameterNoReturn
        MoreParameterNoReturn moreParameterNoReturn = (a,b) -> System.out.println(a+b);
        moreParameterNoReturn.test(2,3);

        //有返回值无参数 NoParameterReturn
        NoParameterReturn noParameterReturn = () -> 4;
        NoParameterReturn noParameterReturn2 = () -> {return 4;};
        System.out.println(noParameterReturn.test());

        //有返回值一个参数 OneParameterReturn
        OneParameterReturn oneParameterReturn = a -> a+12;
        System.out.println(oneParameterReturn.test(3));

        //有返回值多参数  MoreParameterReturn
        MoreParameterReturn moreParameterReturn = (a,b) -> a*b;
        System.out.println(moreParameterReturn.test(2, 10));
    }

    // 用 Lambda简化如下：
    // 无返回值无参数
    public static void main2(String[] args) {
        NoParameterNoReturn noParameterNoReturn = () -> System.out.println("简化重写的test方法");
        noParameterNoReturn.test();
    }

    public static void main1(String[] args) {

        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
            @Override
            public void test() {
                System.out.println("重写的test方法...");
            }
        };
        noParameterNoReturn.test();
    }
}


// 函数式接口 --- 只有一个抽象方法的接口
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}
